The slider control...

Well I call it a slider control, Microsoft calls it a trackbar - here is how Microsoft introduces it:

I have long wanted to use a simple slider control in Liberty Basic. I have been a bit disappointed that Liberty Basic does not offer this as a standard control. To compensate I have written several KLUDGES trying to assemble the various components and code to make a pseudo slider using native Liberty Basic code and graphics. The results have always been less than impressive.

I recently had a cause to integrate one of these kludge of a slider controls into a project I am working on. The result was not very satisfying, and it took a lot of work to adjust the code I was pasting in to be compatible with the existing code modules. To my horror I discovered that almost half of the finished program was code to control this nasty slider.

I decided that there must be a better way. I started out with the concept of implementing a slider wrapper in another language for the Microsoft common controls slider and presenting it to LB as a DLL. What was exciting, as I looked into the control a bit closer, I noticed it conformed very nicely to the same standards which checkbox, statictext, textbox and other common controls conform. I got to wondering if I could just skip the wrapping of the control altogether and just create the control from Liberty Basic.

The good news: This is quite possible. The secret was buried there on Microsoft's MSDN site [http://msdn.microsoft.com]. The CreateWindowsEx function is able to create one from the internal trackbar class. Liberty Basic seems to accept this on a form without issue.

But after the control is created, the question of interface still looms. I found from the MSDN site that the SendMessage function is used to interface with the control. There were still some big issues. The documentation on the MSDN site assumes you are using Microsoft tools with the predefined constants for message type. Liberty Basic does not have these constants predefined. I needed to find a definition.

A search of the internet (thanks Google! [http://www.google.com]) led me to some documentation on the Eiffel website. [http://docs.eiffel.com/eiffelstudio/libraries/wel/reference/consts/wel_tbm_constants_chart.html]

This is a condensed list of the most useful constants for implementation in Liberty Basic including a brief description from the MSDN site:

Each of these (along with many others) are fully explained on the following MSDN website: [http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/commctls/trackbar/reflist.asp. As I noted earlier, I have concentrated on just a few of the possible messages used to control the slider. You may wish to do other unique things which will require some experimentation and study to implement.

Stylebits that can be applied to the control at the time of creation - again I found the integer equivalent values of many of these styles at the Eiffel website - [http://docs.eiffel.com/eiffelstudio/libraries/wel/reference/consts/]:

A slider (or Trackbar) is created using the CreateWindowEx function in the Windows API. Lets take a look at the ugly call:

HWND CreateWindowEx(          
    DWORD dwExStyle,
    LPCTSTR lpClassName,
    LPCTSTR lpWindowName,
    DWORD dwStyle,
    int x,
    int y,
    int nWidth,
    int nHeight,
    HWND hWndParent,
    HMENU hMenu,
    HINSTANCE hInstance,
    LPVOID lpParam
);

Before this function can be called to create the control, you must initialize the common controls interface with the following call:

InitCommonControls(); // loads common control's DLL

Thankfully Alyce Watson has already encapsulated these calls to create similar windows (along with another call I found I needed - GetWindowLong, which is used to subclass a control or window) in her very wonderful and extremely powerful editor Liberty Basic Workshop. I was able to leverage the similar constructed calls to create this new function called CreateSlider:

Function CreateSlider(hW, x, y, w, h)
    CallDLL #comctl32, "InitCommonControls", re As Void
    style = _WS_VISIBLE or _WS_CHILD
    hInst=GetWindowLong(hW, _GWL_HINSTANCE)
    CallDLL #user32, "CreateWindowExA",0 As Long,"msctls_trackbar32" As Ptr,_
        "" As Ptr, style As Long,x As Long,y As Long,w As Long,h As Long,_
        hW As Long, 0 As Long, hInst As Long, 0 As Long,CreateSlider As Long
    End Function

This slider control does not provide many flashy options, but you can alter the styles in the third parameter if the CreateWindowExA call and do some fun stuff. As an additional improvement, you might change the function definition to support passing the styles into the function as a calling argument.

Call this function after the window is open and place the control on the form in the x and y locations using the form coordinante system. The slider will be sized according to w and h. A height of 20 or more is required to display the slider.

Don't forget you will need to add the GetWindowLong function to your program for the code above to actually work:

Function GetWindowLong(hW, type)
    CallDLL #user32, "GetWindowLongA",hW As Long, type As Long,GetWindowLong As Long
    End Function

After the slider is created, use the following function to send various messages to it. I altered the standard SendMessage Sub Program that Alyce has included in Liberty Basic Workshop, turning it into a function. In most cases, this does not make much sense. Sending messages rarely returns a useful value. In the case of the Slider the slide value is however returned via the message GetPos. Here is the SendMessage function:

Function SendMessageLong(hWnd,msg,w,l)
    CallDLL #user32, "SendMessageA", hWnd As Long, _
    msg As Long, w As Long, l As Long, re As Long
    SendMessageLong = re
    End function           

To use all this, include the functions above in your code. The following code will set some general parameters for a typical slider and cause it to be displayed on a window:

    hW = hWnd(#main)
    SlidehW = CreateSlider(hW, 20, 20, 260, 30)
    
    'set the upper range (TBM_SETRANGEMAX = 1032)
    stat = SendMessageLong(SlidehW,1032,True,500)
    'set the lower range (TBM_SETRANGEMIN = 1031)
    stat = SendMessageLong(SlidehW,1031,True,1)
    
    for x = 50 to 500 step 49
        'set tics (TBM_SETTIC = 1028)
        stat = SendMessageLong(SlidehW,1028,True,x)
    next x
    
    'set pagesize (how far a click will move the thumb (TBM_SETPAGESIZE = 1045)
    stat = SendMessageLong(SlidehW,1045,True,49)
    
    'set line size (TBM_SETpos = 1029)
    stat = SendMessageLong(SlidehW,1029,True,98)

In order to detect the changes in value which the slider may be indicating, I created a timer and a routine to scan for the current value:

Timer [checkSlide], 250

[checkSlide]
    'get the value the slider is setting on (TBM_GETPOS = 1024)
    value = SendMessageLong(SlidehW,1024,0,0)
    #main.value, "Current Value: ";value
    wait

This works, but appears not to be the only way to do things. According to the documentation, the control will also send messages that can be intercepted and acted on. Liberty Basic is not able to do this directly, but by using Brent Thorn's WMLiberty subclassing DLL you should be able to capture these messages and avoid using a time to check for updates. This is also good if you are already using WMLiberty in an existing application where you want a slider, as WMLiberty and Timers can not coexist for the same application. I did not research this element of the interface too deeply. If you are interested, these are the messages to watch for:

In addition to this, MSDN notes that Trackbar is capable to responding to several messages that are sent to it. I have not used any of these, but some look useful, and even a couple desirable, such as WM_DESTROY.

DEMO

Finally, I would like to end this article with a nice little Liberty Basic Demo showing a slider (or trackbar) in use.

Editor's note: See slider.bas which is included in the zipped archive of this issue.